/*
NPlot - A charting library for .NET

RectangleBrushes.cs
Copyright (C) 2005
Matt Howlett

Redistribution and use of NPlot or parts there-of in source and
binary forms, with or without modification, are permitted provided
that the following conditions are met:

1. Re-distributions in source form must retain at the head of each
   source file the above copyright notice, this list of conditions
   and the following disclaimer.

2. Any product ("the product") that makes use NPlot or parts 
   there-of must either:
  
    (a) allow any user of the product to obtain a complete machine-
        readable copy of the corresponding source code for the 
        product and the version of NPlot used for a charge no more
        than your cost of physically performing source distribution,
	on a medium customarily used for software interchange, or:

    (b) reproduce the following text in the documentation, about 
        box or other materials intended to be read by human users
        of the product that is provided to every human user of the
        product: 
   
              "This product includes software developed as 
              part of the NPlot library project available 
              from: http://www.nplot.com/" 

        The words "This product" may optionally be replace with 
        the actual name of the product.

------------------------------------------------------------------------

THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

using System;
using System.Drawing;
using System.Drawing.Drawing2D;

namespace NPlot
{

	/// <summary>
	/// Classes that implement this interface can provide a brush 
	/// sized according to a given rectangle.
	/// </summary>
	public interface IRectangleBrush
	{
		/// <summary>
		/// Gets a brush according to the supplied rectangle.
		/// </summary>
		/// <param name="rectangle">the rectangle used to construct the brush</param>
		/// <returns>The brush</returns>
		Brush Get( Rectangle rectangle );
	}

	/// <summary>
	/// Collection of useful brushes.
	/// </summary>
	public class RectangleBrushes
	{

		/// <summary>
		/// A solid brush
		/// </summary>
		public class Solid : IRectangleBrush
		{
			Brush brush_;

			/// <summary>
			/// Constructor
			/// </summary>
			/// <param name="c">brush color</param>
			public Solid( Color c )
			{
				brush_ = new SolidBrush( c );
			}

			/// <summary>
			/// Gets a brush according to the supplied rectangle.
			/// </summary>
			/// <param name="rectangle">the rectangle used to construct the brush</param>
			/// <returns>The solid brush</returns>
			public Brush Get( Rectangle rectangle )
			{
				return brush_;
			}

			#region Default Brushes
			/// <summary>
			/// AliceBlue solid brush.
			/// </summary>
			public static Solid AliceBlue
			{
				get
				{
					return new Solid( Color.AliceBlue );
				}
			}

			/// <summary>
			/// AntiqueWhite solid brush.
			/// </summary>
			public static Solid AntiqueWhite
			{
				get
				{
					return new Solid( Color.AntiqueWhite );
				}
			}

			/// <summary>
			/// Aqua solid brush.
			/// </summary>
			public static Solid Aqua
			{
				get
				{
					return new Solid( Color.Aqua );
				}
			}

			/// <summary>
			/// Aquamarine solid brush.
			/// </summary>
			public static Solid Aquamarine
			{
				get
				{
					return new Solid( Color.Aquamarine );
				}
			}

			/// <summary>
			/// Azure solid brush.
			/// </summary>
			public static Solid Azure
			{
				get
				{
					return new Solid( Color.Azure );
				}
			}

			/// <summary>
			/// Beige solid brush.
			/// </summary>
			public static Solid Beige
			{
				get
				{
					return new Solid( Color.Beige );
				}
			}

			/// <summary>
			/// Bisque solid brush.
			/// </summary>
			public static Solid Bisque
			{
				get
				{
					return new Solid( Color.Bisque );
				}
			}

			/// <summary>
			/// Black solid brush.
			/// </summary>
			public static Solid Black
			{
				get
				{
					return new Solid( Color.Black );
				}
			}

			/// <summary>
			/// BlanchedAlmond solid brush.
			/// </summary>
			public static Solid BlanchedAlmond
			{
				get
				{
					return new Solid( Color.BlanchedAlmond );
				}
			}

			/// <summary>
			/// Blue solid brush.
			/// </summary>
			public static Solid Blue
			{
				get
				{
					return new Solid( Color.Blue );
				}
			}

			/// <summary>
			/// BlueViolet solid brush.
			/// </summary>
			public static Solid BlueViolet
			{
				get
				{
					return new Solid( Color.BlueViolet );
				}
			}

			/// <summary>
			/// Brown solid brush.
			/// </summary>
			public static Solid Brown
			{
				get
				{
					return new Solid( Color.Brown );
				}
			}

			/// <summary>
			/// BurlyWood solid brush.
			/// </summary>
			public static Solid BurlyWood
			{
				get
				{
					return new Solid( Color.BurlyWood );
				}
			}

			/// <summary>
			/// CadetBlue solid brush.
			/// </summary>
			public static Solid CadetBlue
			{
				get
				{
					return new Solid( Color.CadetBlue );
				}
			}

			/// <summary>
			/// Chartreuse solid brush.
			/// </summary>
			public static Solid Chartreuse
			{
				get
				{
					return new Solid( Color.Chartreuse );
				}
			}

			/// <summary>
			/// Chocolate solid brush.
			/// </summary>
			public static Solid Chocolate
			{
				get
				{
					return new Solid( Color.Chocolate );
				}
			}

			/// <summary>
			/// Coral solid brush.
			/// </summary>
			public static Solid Coral
			{
				get
				{
					return new Solid( Color.Coral );
				}
			}

			/// <summary>
			/// CornflowerBlue solid brush.
			/// </summary>
			public static Solid CornflowerBlue
			{
				get
				{
					return new Solid( Color.CornflowerBlue );
				}
			}

			/// <summary>
			/// Cornsilk solid brush.
			/// </summary>
			public static Solid Cornsilk
			{
				get
				{
					return new Solid( Color.Cornsilk );
				}
			}

			/// <summary>
			/// Crimson solid brush.
			/// </summary>
			public static Solid Crimson
			{
				get
				{
					return new Solid( Color.Crimson );
				}
			}

			/// <summary>
			/// Cyan solid brush.
			/// </summary>
			public static Solid Cyan
			{
				get
				{
					return new Solid( Color.Cyan );
				}
			}

			/// <summary>
			/// DarkBlue solid brush.
			/// </summary>
			public static Solid DarkBlue
			{
				get
				{
					return new Solid( Color.DarkBlue );
				}
			}

			/// <summary>
			/// DarkCyan solid brush.
			/// </summary>
			public static Solid DarkCyan
			{
				get
				{
					return new Solid( Color.DarkCyan );
				}
			}

			/// <summary>
			/// DarkGoldenrod solid brush.
			/// </summary>
			public static Solid DarkGoldenrod
			{
				get
				{
					return new Solid( Color.DarkGoldenrod );
				}
			}

			/// <summary>
			/// DarkGray solid brush.
			/// </summary>
			public static Solid DarkGray
			{
				get
				{
					return new Solid( Color.DarkGray );
				}
			}

			/// <summary>
			/// DarkGreen solid brush.
			/// </summary>
			public static Solid DarkGreen
			{
				get
				{
					return new Solid( Color.DarkGreen );
				}
			}

			/// <summary>
			/// DarkKhaki solid brush.
			/// </summary>
			public static Solid DarkKhaki
			{
				get
				{
					return new Solid( Color.DarkKhaki );
				}
			}

			/// <summary>
			/// DarkMagenta solid brush.
			/// </summary>
			public static Solid DarkMagenta
			{
				get
				{
					return new Solid( Color.DarkMagenta );
				}
			}

			/// <summary>
			/// DarkOliveGreen solid brush.
			/// </summary>
			public static Solid DarkOliveGreen
			{
				get
				{
					return new Solid( Color.DarkOliveGreen );
				}
			}

			/// <summary>
			/// DarkOrange solid brush.
			/// </summary>
			public static Solid DarkOrange
			{
				get
				{
					return new Solid( Color.DarkOrange );
				}
			}

			/// <summary>
			/// DarkOrchid solid brush.
			/// </summary>
			public static Solid DarkOrchid
			{
				get
				{
					return new Solid( Color.DarkOrchid );
				}
			}

			/// <summary>
			/// DarkRed solid brush.
			/// </summary>
			public static Solid DarkRed
			{
				get
				{
					return new Solid( Color.DarkRed );
				}
			}

			/// <summary>
			/// DarkSalmon solid brush.
			/// </summary>
			public static Solid DarkSalmon
			{
				get
				{
					return new Solid( Color.DarkSalmon );
				}
			}

			/// <summary>
			/// DarkSeaGreen solid brush.
			/// </summary>
			public static Solid DarkSeaGreen
			{
				get
				{
					return new Solid( Color.DarkSeaGreen );
				}
			}

			/// <summary>
			/// DarkSlateBlue solid brush.
			/// </summary>
			public static Solid DarkSlateBlue
			{
				get
				{
					return new Solid( Color.DarkSlateBlue );
				}
			}

			/// <summary>
			/// DarkSlateGray solid brush.
			/// </summary>
			public static Solid DarkSlateGray
			{
				get
				{
					return new Solid( Color.DarkSlateGray );
				}
			}

			/// <summary>
			/// DarkTurquoise solid brush.
			/// </summary>
			public static Solid DarkTurquoise
			{
				get
				{
					return new Solid( Color.DarkTurquoise );
				}
			}

			/// <summary>
			/// DarkViolet solid brush.
			/// </summary>
			public static Solid DarkViolet
			{
				get
				{
					return new Solid( Color.DarkViolet );
				}
			}

			/// <summary>
			/// DeepPink solid brush.
			/// </summary>
			public static Solid DeepPink
			{
				get
				{
					return new Solid( Color.DeepPink );
				}
			}

			/// <summary>
			/// DeepSkyBlue solid brush.
			/// </summary>
			public static Solid DeepSkyBlue
			{
				get
				{
					return new Solid( Color.DeepSkyBlue );
				}
			}

			/// <summary>
			/// DimGray solid brush.
			/// </summary>
			public static Solid DimGray
			{
				get
				{
					return new Solid( Color.DimGray );
				}
			}

			/// <summary>
			/// DodgerBlue solid brush.
			/// </summary>
			public static Solid DodgerBlue
			{
				get
				{
					return new Solid( Color.DodgerBlue );
				}
			}

			/// <summary>
			/// Firebrick solid brush.
			/// </summary>
			public static Solid Firebrick
			{
				get
				{
					return new Solid( Color.Firebrick );
				}
			}

			/// <summary>
			/// FloralWhite solid brush.
			/// </summary>
			public static Solid FloralWhite
			{
				get
				{
					return new Solid( Color.FloralWhite );
				}
			}

			/// <summary>
			/// ForestGreen solid brush.
			/// </summary>
			public static Solid ForestGreen
			{
				get
				{
					return new Solid( Color.ForestGreen );
				}
			}

			/// <summary>
			/// Fuchsia solid brush.
			/// </summary>
			public static Solid Fuchsia
			{
				get
				{
					return new Solid( Color.Fuchsia );
				}
			}

			/// <summary>
			/// Gainsboro solid brush.
			/// </summary>
			public static Solid Gainsboro
			{
				get
				{
					return new Solid( Color.Gainsboro );
				}
			}

			/// <summary>
			/// GhostWhite solid brush.
			/// </summary>
			public static Solid GhostWhite
			{
				get
				{
					return new Solid( Color.GhostWhite );
				}
			}

			/// <summary>
			/// Gold solid brush.
			/// </summary>
			public static Solid Gold
			{
				get
				{
					return new Solid( Color.Gold );
				}
			}

			/// <summary>
			/// Goldenrod solid brush.
			/// </summary>
			public static Solid Goldenrod
			{
				get
				{
					return new Solid( Color.Goldenrod );
				}
			}

			/// <summary>
			/// Gray  solid brush.
			/// </summary>
			public static Solid Gray 
			{
				get
				{
					return new Solid( Color.Gray );
				}
			}

			/// <summary>
			/// Green solid brush.
			/// </summary>
			public static Solid Green
			{
				get
				{
					return new Solid( Color.Green );
				}
			}

			/// <summary>
			/// GreenYellow solid brush.
			/// </summary>
			public static Solid GreenYellow
			{
				get
				{
					return new Solid( Color.GreenYellow );
				}
			}

			/// <summary>
			/// Honeydew solid brush.
			/// </summary>
			public static Solid Honeydew
			{
				get
				{
					return new Solid( Color.Honeydew );
				}
			}

			/// <summary>
			/// HotPink solid brush.
			/// </summary>
			public static Solid HotPink
			{
				get
				{
					return new Solid( Color.HotPink );
				}
			}

			/// <summary>
			/// IndianRed solid brush.
			/// </summary>
			public static Solid IndianRed
			{
				get
				{
					return new Solid( Color.IndianRed );
				}
			}

			/// <summary>
			/// Indigo solid brush.
			/// </summary>
			public static Solid Indigo
			{
				get
				{
					return new Solid( Color.Indigo );
				}
			}

			/// <summary>
			/// Ivory solid brush.
			/// </summary>
			public static Solid Ivory
			{
				get
				{
					return new Solid( Color.Ivory );
				}
			}

			/// <summary>
			/// Khaki solid brush.
			/// </summary>
			public static Solid Khaki
			{
				get
				{
					return new Solid( Color.Khaki );
				}
			}

			/// <summary>
			/// Lavender solid brush.
			/// </summary>
			public static Solid Lavender
			{
				get
				{
					return new Solid( Color.Lavender );
				}
			}

			/// <summary>
			/// LavenderBlush solid brush.
			/// </summary>
			public static Solid LavenderBlush
			{
				get
				{
					return new Solid( Color.LavenderBlush );
				}
			}

			/// <summary>
			/// LawnGreen solid brush.
			/// </summary>
			public static Solid LawnGreen
			{
				get
				{
					return new Solid( Color.LawnGreen );
				}
			}

			/// <summary>
			/// LemonChiffon solid brush.
			/// </summary>
			public static Solid LemonChiffon
			{
				get
				{
					return new Solid( Color.LemonChiffon );
				}
			}

			/// <summary>
			/// LightBlue solid brush.
			/// </summary>
			public static Solid LightBlue
			{
				get
				{
					return new Solid( Color.LightBlue );
				}
			}

			/// <summary>
			/// LightCoral solid brush.
			/// </summary>
			public static Solid LightCoral
			{
				get
				{
					return new Solid( Color.LightCoral );
				}
			}

			/// <summary>
			/// LightCyan solid brush.
			/// </summary>
			public static Solid LightCyan
			{
				get
				{
					return new Solid( Color.LightCyan );
				}
			}

			/// <summary>
			/// LightGoldenrodYellow solid brush.
			/// </summary>
			public static Solid LightGoldenrodYellow
			{
				get
				{
					return new Solid( Color.LightGoldenrodYellow );
				}
			}

			/// <summary>
			/// LightGray solid brush.
			/// </summary>
			public static Solid LightGray
			{
				get
				{
					return new Solid( Color.LightGray );
				}
			}

			/// <summary>
			/// LightGreen solid brush.
			/// </summary>
			public static Solid LightGreen
			{
				get
				{
					return new Solid( Color.LightGreen );
				}
			}

			/// <summary>
			/// LightPink solid brush.
			/// </summary>
			public static Solid LightPink
			{
				get
				{
					return new Solid( Color.LightPink );
				}
			}

			/// <summary>
			/// LightSalmon solid brush.
			/// </summary>
			public static Solid LightSalmon
			{
				get
				{
					return new Solid( Color.LightSalmon );
				}
			}

			/// <summary>
			/// LightSeaGreen solid brush.
			/// </summary>
			public static Solid LightSeaGreen
			{
				get
				{
					return new Solid( Color.LightSeaGreen );
				}
			}

			/// <summary>
			/// LightSkyBlue solid brush.
			/// </summary>
			public static Solid LightSkyBlue
			{
				get
				{
					return new Solid( Color.LightSkyBlue );
				}
			}

			/// <summary>
			/// LightSlateGray solid brush.
			/// </summary>
			public static Solid LightSlateGray
			{
				get
				{
					return new Solid( Color.LightSlateGray );
				}
			}

			/// <summary>
			/// LightSteelBlue solid brush.
			/// </summary>
			public static Solid LightSteelBlue
			{
				get
				{
					return new Solid( Color.LightSteelBlue );
				}
			}

			/// <summary>
			/// LightYellow solid brush.
			/// </summary>
			public static Solid LightYellow
			{
				get
				{
					return new Solid( Color.LightYellow );
				}
			}

			/// <summary>
			/// Lime solid brush.
			/// </summary>
			public static Solid Lime
			{
				get
				{
					return new Solid( Color.Lime );
				}
			}

			/// <summary>
			/// LimeGreen solid brush.
			/// </summary>
			public static Solid LimeGreen
			{
				get
				{
					return new Solid( Color.LimeGreen );
				}
			}

			/// <summary>
			/// Color.Linen solid brush.
			/// </summary>
			public static Solid Linen
			{
				get
				{
					return new Solid( Color.Linen );
				}
			}

			/// <summary>
			/// Color.Magenta solid brush.
			/// </summary>
			public static Solid Magenta
			{
				get
				{
					return new Solid( Color.Magenta );
				}
			}

			/// <summary>
			/// Maroon solid brush.
			/// </summary>
			public static Solid Maroon
			{
				get
				{
					return new Solid( Color.Maroon );
				}
			}

			/// <summary>
			/// MediumAquamarine solid brush.
			/// </summary>
			public static Solid MediumAquamarine
			{
				get
				{
					return new Solid( Color.MediumAquamarine );
				}
			}

			/// <summary>
			/// MediumBlue solid brush.
			/// </summary>
			public static Solid MediumBlue
			{
				get
				{
					return new Solid( Color.MediumBlue );
				}
			}

			/// <summary>
			/// MediumOrchid  solid brush.
			/// </summary>
			public static Solid MediumOrchid 
			{
				get
				{
					return new Solid( Color.MediumOrchid );
				}
			}

			/// <summary>
			/// MediumPurple solid brush.
			/// </summary>
			public static Solid MediumPurple
			{
				get
				{
					return new Solid( Color.MediumPurple );
				}
			}

			/// <summary>
			/// MediumSeaGreen solid brush.
			/// </summary>
			public static Solid MediumSeaGreen
			{
				get
				{
					return new Solid( Color.MediumSeaGreen );
				}
			}

			/// <summary>
			/// MediumSlateBlue solid brush.
			/// </summary>
			public static Solid MediumSlateBlue
			{
				get
				{
					return new Solid( Color.MediumSlateBlue );
				}
			}

			/// <summary>
			/// MediumSpringGreen solid brush.
			/// </summary>
			public static Solid MediumSpringGreen
			{
				get
				{
					return new Solid( Color.MediumSpringGreen );
				}
			}

			/// <summary>
			/// MediumTurquoise solid brush.
			/// </summary>
			public static Solid MediumTurquoise
			{
				get
				{
					return new Solid( Color.MediumTurquoise );
				}
			}

			/// <summary>
			/// MediumVioletRed solid brush.
			/// </summary>
			public static Solid MediumVioletRed
			{
				get
				{
					return new Solid( Color.MediumVioletRed );
				}
			}

			/// <summary>
			/// MidnightBlue  solid brush.
			/// </summary>
			public static Solid MidnightBlue 
			{
				get
				{
					return new Solid( Color.MidnightBlue );
				}
			}

			/// <summary>
			/// MintCream solid brush.
			/// </summary>
			public static Solid MintCream
			{
				get
				{
					return new Solid( Color.MintCream );
				}
			}

			/// <summary>
			/// MistyRose solid brush.
			/// </summary>
			public static Solid MistyRose
			{
				get
				{
					return new Solid( Color.MistyRose );
				}
			}

			/// <summary>
			/// Moccasin solid brush.
			/// </summary>
			public static Solid Moccasin
			{
				get
				{
					return new Solid( Color.Moccasin );
				}
			}

			/// <summary>
			/// NavajoWhite solid brush.
			/// </summary>
			public static Solid NavajoWhite
			{
				get
				{
					return new Solid( Color.NavajoWhite );
				}
			}

			/// <summary>
			/// Navy solid brush.
			/// </summary>
			public static Solid Navy
			{
				get
				{
					return new Solid( Color.Navy );
				}
			}

			/// <summary>
			/// OldLace solid brush.
			/// </summary>
			public static Solid OldLace
			{
				get
				{
					return new Solid( Color.OldLace );
				}
			}

			/// <summary>
			/// Olive solid brush.
			/// </summary>
			public static Solid Olive
			{
				get
				{
					return new Solid( Color.Olive );
				}
			}

			/// <summary>
			/// OliveDrab solid brush.
			/// </summary>
			public static Solid OliveDrab
			{
				get
				{
					return new Solid( Color.OliveDrab );
				}
			}

			/// <summary>
			/// Orange solid brush.
			/// </summary>
			public static Solid Orange
			{
				get
				{
					return new Solid( Color.Orange );
				}
			}

			/// <summary>
			/// OrangeRed solid brush.
			/// </summary>
			public static Solid OrangeRed
			{
				get
				{
					return new Solid( Color.OrangeRed );
				}
			}

			/// <summary>
			/// Orchid solid brush.
			/// </summary>
			public static Solid Orchid
			{
				get
				{
					return new Solid( Color.Orchid );
				}
			}

			/// <summary>
			/// PaleGoldenrod solid brush.
			/// </summary>
			public static Solid PaleGoldenrod
			{
				get
				{
					return new Solid( Color.PaleGoldenrod );
				}
			}

			/// <summary>
			/// PaleGreen solid brush.
			/// </summary>
			public static Solid PaleGreen
			{
				get
				{
					return new Solid( Color.PaleGreen );
				}
			}

			/// <summary>
			/// PaleTurquoise solid brush.
			/// </summary>
			public static Solid PaleTurquoise
			{
				get
				{
					return new Solid( Color.PaleTurquoise );
				}
			}

			/// <summary>
			/// PaleVioletRed solid brush.
			/// </summary>
			public static Solid PaleVioletRed
			{
				get
				{
					return new Solid( Color.PaleVioletRed );
				}
			}

			/// <summary>
			/// PapayaWhip solid brush.
			/// </summary>
			public static Solid PapayaWhip
			{
				get
				{
					return new Solid( Color.PapayaWhip );
				}
			}

			/// <summary>
			/// PeachPuff solid brush.
			/// </summary>
			public static Solid PeachPuff
			{
				get
				{
					return new Solid( Color.PeachPuff );
				}
			}

			/// <summary>
			/// Peru solid brush.
			/// </summary>
			public static Solid Peru
			{
				get
				{
					return new Solid( Color.Peru );
				}
			}

			/// <summary>
			/// Pink solid brush.
			/// </summary>
			public static Solid Pink
			{
				get
				{
					return new Solid( Color.Pink );
				}
			}

			/// <summary>
			/// Plum solid brush.
			/// </summary>
			public static Solid Plum
			{
				get
				{
					return new Solid( Color.Plum );
				}
			}

			/// <summary>
			/// PowderBlue solid brush.
			/// </summary>
			public static Solid PowderBlue
			{
				get
				{
					return new Solid( Color.PowderBlue );
				}
			}

			/// <summary>
			/// Purple solid brush.
			/// </summary>
			public static Solid Purple
			{
				get
				{
					return new Solid( Color.Purple );
				}
			}

			/// <summary>
			/// Red solid brush.
			/// </summary>
			public static Solid Red
			{
				get
				{
					return new Solid( Color.Red );
				}
			}

			/// <summary>
			/// RosyBrown solid brush.
			/// </summary>
			public static Solid RosyBrown
			{
				get
				{
					return new Solid( Color.RosyBrown );
				}
			}

			/// <summary>
			/// RoyalBlue solid brush.
			/// </summary>
			public static Solid RoyalBlue
			{
				get
				{
					return new Solid( Color.RoyalBlue );
				}
			}

			/// <summary>
			/// SaddleBrown solid brush.
			/// </summary>
			public static Solid SaddleBrown
			{
				get
				{
					return new Solid( Color.SaddleBrown );
				}
			}

			/// <summary>
			/// Salmon solid brush.
			/// </summary>
			public static Solid Salmon
			{
				get
				{
					return new Solid( Color.Salmon );
				}
			}

			/// <summary>
			/// SandyBrown solid brush.
			/// </summary>
			public static Solid SandyBrown
			{
				get
				{
					return new Solid( Color.SandyBrown );
				}
			}

			/// <summary>
			/// SeaGreen solid brush.
			/// </summary>
			public static Solid SeaGreen
			{
				get
				{
					return new Solid( Color.SeaGreen );
				}
			}

			/// <summary>
			/// SeaShell solid brush.
			/// </summary>
			public static Solid SeaShell
			{
				get
				{
					return new Solid( Color.SeaShell );
				}
			}

			/// <summary>
			/// Sienna solid brush.
			/// </summary>
			public static Solid Sienna
			{
				get
				{
					return new Solid( Color.Sienna );
				}
			}

			/// <summary>
			/// Silver solid brush.
			/// </summary>
			public static Solid Silver
			{
				get
				{
					return new Solid( Color.Silver );
				}
			}

			/// <summary>
			/// SkyBlue solid brush.
			/// </summary>
			public static Solid SkyBlue
			{
				get
				{
					return new Solid( Color.SkyBlue );
				}
			}

			/// <summary>
			/// SlateBlue solid brush.
			/// </summary>
			public static Solid SlateBlue
			{
				get
				{
					return new Solid( Color.SlateBlue );
				}
			}

			/// <summary>
			/// SlateGray solid brush.
			/// </summary>
			public static Solid SlateGray
			{
				get
				{
					return new Solid( Color.SlateGray );
				}
			}

			/// <summary>
			/// Snow solid brush.
			/// </summary>
			public static Solid Snow
			{
				get
				{
					return new Solid( Color.Snow );
				}
			}

			/// <summary>
			/// SpringGreen solid brush.
			/// </summary>
			public static Solid SpringGreen
			{
				get
				{
					return new Solid( Color.SpringGreen );
				}
			}

			/// <summary>
			/// SteelBlue solid brush.
			/// </summary>
			public static Solid SteelBlue
			{
				get
				{
					return new Solid( Color.SteelBlue );
				}
			}

			/// <summary>
			/// Tan solid brush.
			/// </summary>
			public static Solid Tan
			{
				get
				{
					return new Solid( Color.Tan );
				}
			}

			/// <summary>
			/// Teal solid brush.
			/// </summary>
			public static Solid Teal
			{
				get
				{
					return new Solid( Color.Teal );
				}
			}

			/// <summary>
			/// Thistle solid brush.
			/// </summary>
			public static Solid Thistle
			{
				get
				{
					return new Solid( Color.Thistle );
				}
			}

			/// <summary>
			/// Tomato solid brush.
			/// </summary>
			public static Solid Tomato
			{
				get
				{
					return new Solid( Color.Tomato );
				}
			}

			/// <summary>
			/// Transparent solid brush.
			/// </summary>
			public static Solid Transparent
			{
				get
				{
					return new Solid( Color.Transparent );
				}
			}

			/// <summary>
			/// Turquoise solid brush.
			/// </summary>
			public static Solid Turquoise
			{
				get
				{
					return new Solid( Color.Turquoise );
				}
			}

			/// <summary>
			/// Violet solid brush.
			/// </summary>
			public static Solid Violet
			{
				get
				{
					return new Solid( Color.Violet );
				}
			}

			/// <summary>
			/// Wheat solid brush.
			/// </summary>
			public static Solid Wheat
			{
				get
				{
					return new Solid( Color.Wheat );
				}
			}

			/// <summary>
			/// White solid brush.
			/// </summary>
			public static Solid White
			{
				get
				{
					return new Solid( Color.White );
				}
			}

			/// <summary>
			/// WhiteSmoke solid brush.
			/// </summary>
			public static Solid WhiteSmoke
			{
				get
				{
					return new Solid( Color.WhiteSmoke );
				}
			}

			/// <summary>
			/// Yellow solid brush.
			/// </summary>
			public static Solid Yellow
			{
				get
				{
					return new Solid( Color.Yellow );
				}
			}

			/// <summary>
			/// YellowGreen solid brush.
			/// </summary>
			public static Solid YellowGreen
			{
				get
				{
					return new Solid( Color.YellowGreen );
				}
			}

			#endregion

		}


		/// <summary>
		/// A brush with horizontal gradient.
		/// </summary>
		public class Horizontal : IRectangleBrush
		{
			private Color c1_;
			private Color c2_;
			
			/// <summary>
			/// Constructor
			/// </summary>
			/// <param name="c1">Color on left.</param>
			/// <param name="c2">Color on right.</param>
			public Horizontal( Color c1, Color c2 )
			{
				c1_ = c1;
				c2_ = c2;
			}

			/// <summary>
			/// Gets a brush according to the supplied rectangle.
			/// </summary>
			/// <param name="rectangle">the rectangle used to construct the brush</param>
			/// <returns>The horizontal brush</returns>
			public Brush Get( Rectangle rectangle )
			{
				return new LinearGradientBrush( rectangle, c1_, c2_, LinearGradientMode.Horizontal );
			}

			#region DefaultBrushes

			/// <summary>
			/// Default brush - fades from faint blue to white.
			/// </summary>
			public static Horizontal FaintBlueFade
			{
				get
				{
					return new Horizontal( Color.FromArgb(200,200,255), Color.FromArgb(255,255,255) );
				}
			}

			/// <summary>
			/// Default brush - fades from faint red to white.
			/// </summary>
			public static Horizontal FaintRedFade
			{
				get
				{
					return new Horizontal( Color.FromArgb(255,200,200), Color.FromArgb(255,255,255) );
				}
			}

			/// <summary>
			/// Default brush - fades from faint red to white.
			/// </summary>
			public static Horizontal FaintGreenFade
			{
				get
				{
					return new Horizontal( Color.FromArgb(200,255,200), Color.FromArgb(255,255,255) );
				}
			}

			#endregion

		}


		/// <summary>
		/// A brush with vertical gradient.
		/// </summary>
		public class Vertical : IRectangleBrush
		{
			private Color c1_;
			private Color c2_;
			
			/// <summary>
			/// Constructor
			/// </summary>
			/// <param name="c1">top color [or bottom?]</param>
			/// <param name="c2">bottom color [or top?]</param>
			public Vertical( Color c1, Color c2 )
			{
				c1_ = c1;
				c2_ = c2;
			}

			/// <summary>
			/// Gets a brush according to the supplied rectangle.
			/// </summary>
			/// <param name="rectangle">the rectangle used to construct the brush</param>
			/// <returns>The vertical brush</returns>
			public Brush Get( Rectangle rectangle )
			{
				return new LinearGradientBrush( rectangle, c1_, c2_, LinearGradientMode.Vertical );
			}


			#region DefaultBrushes

			/// <summary>
			/// Default brush - fades from faint blue to white.
			/// </summary>
			public static Vertical FaintBlueFade
			{
				get
				{
					return new Vertical( Color.FromArgb(200,200,255), Color.FromArgb(255,255,255) );
				}
			}

			/// <summary>
			/// Default brush - fades from faint red to white.
			/// </summary>
			public static Vertical FaintRedFade
			{
				get
				{
					return new Vertical( Color.FromArgb(255,200,200), Color.FromArgb(255,255,255) );
				}
			}

			/// <summary>
			/// Default brush - fades from faint red to white.
			/// </summary>
			public static Vertical FaintGreenFade
			{
				get
				{
					return new Vertical( Color.FromArgb(200,255,200), Color.FromArgb(255,255,255) );
				}
			}

			#endregion
		}


		/// <summary>
		/// A brush with horizontal gradient that fades into center then out again.
		/// </summary>
		public class HorizontalCenterFade : IRectangleBrush
		{
			private Color c1_;
			private Color c2_;

			/// <summary>
			/// Constructor
			/// </summary>
			/// <param name="c1">inner color</param>
			/// <param name="c2">outer color</param>
			public HorizontalCenterFade( Color c1, Color c2 )
			{
				c1_ = c1;
				c2_ = c2;
			}

			/// <summary>
			/// Gets a brush according to the supplied rectangle.
			/// </summary>
			/// <param name="rectangle">the rectangle used to construct the brush</param>
			/// <returns>The horizontal center fade brush</returns>
			public Brush Get( Rectangle rectangle )
			{
				LinearGradientBrush brush = new LinearGradientBrush( rectangle, c1_, c2_, LinearGradientMode.Horizontal );
				float[] relativeIntensities = { 0.0f, 0.9f, 1.0f, 0.9f, 0.0f };
				float[] relativePositions   = { 0.0f, 0.4f, 0.5f, 0.6f, 1.0f };
				Blend blend = new Blend();
				blend.Factors = relativeIntensities;
				blend.Positions = relativePositions;
				brush.Blend = blend;
				return brush;
			}

			#region DefaultBrushes

			/// <summary>
			/// Default brush - fades from faint blue to white.
			/// </summary>
			public static HorizontalCenterFade FaintBlueFade
			{
				get
				{
					return new HorizontalCenterFade( Color.FromArgb(200,200,255), Color.FromArgb(255,255,255) );
				}
			}

			/// <summary>
			/// Default brush - fades from faint red to white.
			/// </summary>
			public static HorizontalCenterFade FaintRedFade
			{
				get
				{
					return new HorizontalCenterFade( Color.FromArgb(255,200,200), Color.FromArgb(255,255,255) );
				}
			}

			/// <summary>
			/// Default brush - fades from faint red to white.
			/// </summary>
			public static HorizontalCenterFade FaintGreenFade
			{
				get
				{
					return new HorizontalCenterFade( Color.FromArgb(200,255,200), Color.FromArgb(255,255,255) );
				}
			}

			#endregion
		}



		/// <summary>
		/// Brush with vertical gradient that fades into center then out again.
		/// </summary>
		public class VerticalCenterFade : IRectangleBrush
		{
			private Color c1_;
			private Color c2_;

			/// <summary>
			/// Constructor
			/// </summary>
			/// <param name="c1">inner color</param>
			/// <param name="c2">outer color</param>
			public VerticalCenterFade( Color c1, Color c2 )
			{
				c1_ = c1;
				c2_ = c2;
			}

			/// <summary>
			/// Gets a brush according to the supplied rectangle.
			/// </summary>
			/// <param name="rectangle">the rectangle used to construct the brush</param>
			/// <returns>The vertical center fade brush</returns>
			public Brush Get( Rectangle rectangle )
			{
				LinearGradientBrush brush = new LinearGradientBrush( rectangle, c1_, c2_, LinearGradientMode.Vertical );
				float[] relativeIntensities = { 0.0f, 0.9f, 1.0f, 0.9f, 0.0f };
				float[] relativePositions   = { 0.0f, 0.4f, 0.5f, 0.6f, 1.0f };
				Blend blend = new Blend();
				blend.Factors = relativeIntensities;
				blend.Positions = relativePositions;
				brush.Blend = blend;
				return brush;
			}

			#region DefaultBrushes

			/// <summary>
			/// Default brush - fades from faint blue to white.
			/// </summary>
			public static VerticalCenterFade FaintBlueFade
			{
				get
				{
					return new VerticalCenterFade( Color.FromArgb(200,200,255), Color.FromArgb(255,255,255) );
				}
			}

			/// <summary>
			/// Default brush - fades from faint red to white.
			/// </summary>
			public static VerticalCenterFade FaintRedFade
			{
				get
				{
					return new VerticalCenterFade( Color.FromArgb(255,200,200), Color.FromArgb(255,255,255) );
				}
			}

			/// <summary>
			/// Default brush - fades from faint red to white.
			/// </summary>
			public static VerticalCenterFade FaintGreenFade
			{
				get
				{
					return new VerticalCenterFade( Color.FromArgb(200,255,200), Color.FromArgb(255,255,255) );
				}
			}

			#endregion

		}


	}
}
